home *** CD-ROM | disk | FTP | other *** search
/ Aminet 38 / Aminet 38 (2000)(Schatztruhe)[!][Aug 2000].iso / Aminet / dev / c / CLib-SDI.lha / CLib-SDI / include2 / inline / dos.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-06-25  |  21.4 KB  |  692 lines
  1. #ifndef _INLINE_DOS_H
  2. #define _INLINE_DOS_H
  3.  
  4. #ifndef __INLINE_MACROS_H
  5. #include <inline/macros.h>
  6. #endif
  7.  
  8. #ifndef DOS_BASE_NAME
  9. #define DOS_BASE_NAME DOSBase
  10. #endif
  11.  
  12. #define Open(name, accessMode) \
  13.     LP2(0x1E, BPTR, Open, CONST_STRPTR, name, d1, LONG, accessMode, d2, \
  14.     , DOS_BASE_NAME)
  15.  
  16. #define Close(file) \
  17.     LP1(0x24, LONG, Close, BPTR, file, d1, \
  18.     , DOS_BASE_NAME)
  19.  
  20. #define Read(file, buffer, length) \
  21.     LP3(0x2A, LONG, Read, BPTR, file, d1, APTR, buffer, d2, LONG, length, d3, \
  22.     , DOS_BASE_NAME)
  23.  
  24. #define Write(file, buffer, length) \
  25.     LP3(0x30, LONG, Write, BPTR, file, d1, CONST APTR, buffer, d2, LONG, length, d3, \
  26.     , DOS_BASE_NAME)
  27.  
  28. #define Input() \
  29.     LP0(0x36, BPTR, Input, \
  30.     , DOS_BASE_NAME)
  31.  
  32. #define Output() \
  33.     LP0(0x3C, BPTR, Output, \
  34.     , DOS_BASE_NAME)
  35.  
  36. #define Seek(file, position, offset) \
  37.     LP3(0x42, LONG, Seek, BPTR, file, d1, LONG, position, d2, LONG, offset, d3, \
  38.     , DOS_BASE_NAME)
  39.  
  40. #define DeleteFile(name) \
  41.     LP1(0x48, LONG, DeleteFile, CONST_STRPTR, name, d1, \
  42.     , DOS_BASE_NAME)
  43.  
  44. #define Rename(oldName, newName) \
  45.     LP2(0x4E, LONG, Rename, CONST_STRPTR, oldName, d1, CONST_STRPTR, newName, d2, \
  46.     , DOS_BASE_NAME)
  47.  
  48. #define Lock(name, type) \
  49.     LP2(0x54, BPTR, Lock, CONST_STRPTR, name, d1, LONG, type, d2, \
  50.     , DOS_BASE_NAME)
  51.  
  52. #define UnLock(lock) \
  53.     LP1NR(0x5A, UnLock, BPTR, lock, d1, \
  54.     , DOS_BASE_NAME)
  55.  
  56. #define DupLock(lock) \
  57.     LP1(0x60, BPTR, DupLock, BPTR, lock, d1, \
  58.     , DOS_BASE_NAME)
  59.  
  60. #define Examine(lock, fileInfoBlock) \
  61.     LP2(0x66, LONG, Examine, BPTR, lock, d1, struct FileInfoBlock *, fileInfoBlock, d2, \
  62.     , DOS_BASE_NAME)
  63.  
  64. #define ExNext(lock, fileInfoBlock) \
  65.     LP2(0x6C, LONG, ExNext, BPTR, lock, d1, struct FileInfoBlock *, fileInfoBlock, d2, \
  66.     , DOS_BASE_NAME)
  67.  
  68. #define Info(lock, parameterBlock) \
  69.     LP2(0x72, LONG, Info, BPTR, lock, d1, struct InfoData *, parameterBlock, d2, \
  70.     , DOS_BASE_NAME)
  71.  
  72. #define CreateDir(name) \
  73.     LP1(0x78, BPTR, CreateDir, CONST_STRPTR, name, d1, \
  74.     , DOS_BASE_NAME)
  75.  
  76. #define CurrentDir(lock) \
  77.     LP1(0x7E, BPTR, CurrentDir, BPTR, lock, d1, \
  78.     , DOS_BASE_NAME)
  79.  
  80. #define IoErr() \
  81.     LP0(0x84, LONG, IoErr, \
  82.     , DOS_BASE_NAME)
  83.  
  84. #define CreateProc(name, pri, segList, stackSize) \
  85.     LP4(0x8A, struct MsgPort *, CreateProc, CONST_STRPTR, name, d1, LONG, pri, d2, BPTR, segList, d3, LONG, stackSize, d4, \
  86.     , DOS_BASE_NAME)
  87.  
  88. #define Exit(returnCode) \
  89.     LP1NR(0x90, Exit, LONG, returnCode, d1, \
  90.     , DOS_BASE_NAME)
  91.  
  92. #define LoadSeg(name) \
  93.     LP1(0x96, BPTR, LoadSeg, CONST_STRPTR, name, d1, \
  94.     , DOS_BASE_NAME)
  95.  
  96. #define UnLoadSeg(seglist) \
  97.     LP1NR(0x9C, UnLoadSeg, BPTR, seglist, d1, \
  98.     , DOS_BASE_NAME)
  99.  
  100. #define DeviceProc(name) \
  101.     LP1(0xAE, struct MsgPort *, DeviceProc, CONST_STRPTR, name, d1, \
  102.     , DOS_BASE_NAME)
  103.  
  104. #define SetComment(name, comment) \
  105.     LP2(0xB4, LONG, SetComment, CONST_STRPTR, name, d1, CONST_STRPTR, comment, d2, \
  106.     , DOS_BASE_NAME)
  107.  
  108. #define SetProtection(name, protect) \
  109.     LP2(0xBA, LONG, SetProtection, CONST_STRPTR, name, d1, LONG, protect, d2, \
  110.     , DOS_BASE_NAME)
  111.  
  112. #define DateStamp(date) \
  113.     LP1(0xC0, struct DateStamp *, DateStamp, struct DateStamp *, date, d1, \
  114.     , DOS_BASE_NAME)
  115.  
  116. #define Delay(timeout) \
  117.     LP1NR(0xC6, Delay, LONG, timeout, d1, \
  118.     , DOS_BASE_NAME)
  119.  
  120. #define WaitForChar(file, timeout) \
  121.     LP2(0xCC, LONG, WaitForChar, BPTR, file, d1, LONG, timeout, d2, \
  122.     , DOS_BASE_NAME)
  123.  
  124. #define ParentDir(lock) \
  125.     LP1(0xD2, BPTR, ParentDir, BPTR, lock, d1, \
  126.     , DOS_BASE_NAME)
  127.  
  128. #define IsInteractive(file) \
  129.     LP1(0xD8, LONG, IsInteractive, BPTR, file, d1, \
  130.     , DOS_BASE_NAME)
  131.  
  132. #define Execute(string, file, file2) \
  133.     LP3(0xDE, LONG, Execute, CONST_STRPTR, string, d1, BPTR, file, d2, BPTR, file2, d3, \
  134.     , DOS_BASE_NAME)
  135.  
  136. #define AllocDosObject(type, tags) \
  137.     LP2(0xE4, APTR, AllocDosObject, ULONG, type, d1, CONST struct TagItem *, tags, d2, \
  138.     , DOS_BASE_NAME)
  139.  
  140. #ifndef NO_INLINE_STDARG
  141. #define AllocDosObjectTags(type, tags...) \
  142.     ({ULONG _tags[] = {tags}; AllocDosObject((type), (CONST struct TagItem *) _tags);})
  143. #endif
  144.  
  145. #define AllocDosObjectTagList(type, tags) AllocDosObject((type), (tags))
  146.  
  147. #define FreeDosObject(type, ptr) \
  148.     LP2NR(0xEA, FreeDosObject, ULONG, type, d1, APTR, ptr, d2, \
  149.     , DOS_BASE_NAME)
  150.  
  151. #define DoPkt(port, action, arg1, arg2, arg3, arg4, arg5) \
  152.     LP7(0xF0, LONG, DoPkt, struct MsgPort *, port, d1, LONG, action, d2, LONG, arg1, d3, LONG, arg2, d4, LONG, arg3, d5, LONG, arg4, d6, LONG, arg5, d7, \
  153.     , DOS_BASE_NAME)
  154.  
  155. #define DoPkt0(port, action) \
  156.     LP2(0xF0, LONG, DoPkt0, struct MsgPort *, port, d1, LONG, action, d2, \
  157.     , DOS_BASE_NAME)
  158.  
  159. #define DoPkt1(port, action, arg1) \
  160.     LP3(0xF0, LONG, DoPkt1, struct MsgPort *, port, d1, LONG, action, d2, LONG, arg1, d3, \
  161.     , DOS_BASE_NAME)
  162.  
  163. #define DoPkt2(port, action, arg1, arg2) \
  164.     LP4(0xF0, LONG, DoPkt2, struct MsgPort *, port, d1, LONG, action, d2, LONG, arg1, d3, LONG, arg2, d4, \
  165.     , DOS_BASE_NAME)
  166.  
  167. #define DoPkt3(port, action, arg1, arg2, arg3) \
  168.     LP5(0xF0, LONG, DoPkt3, struct MsgPort *, port, d1, LONG, action, d2, LONG, arg1, d3, LONG, arg2, d4, LONG, arg3, d5, \
  169.     , DOS_BASE_NAME)
  170.  
  171. #define DoPkt4(port, action, arg1, arg2, arg3, arg4) \
  172.     LP6(0xF0, LONG, DoPkt4, struct MsgPort *, port, d1, LONG, action, d2, LONG, arg1, d3, LONG, arg2, d4, LONG, arg3, d5, LONG, arg4, d6, \
  173.     , DOS_BASE_NAME)
  174.  
  175. #define SendPkt(dp, port, replyport) \
  176.     LP3NR(0xF6, SendPkt, struct DosPacket *, dp, d1, struct MsgPort *, port, d2, struct MsgPort *, replyport, d3, \
  177.     , DOS_BASE_NAME)
  178.  
  179. #define WaitPkt() \
  180.     LP0(0xFC, struct DosPacket *, WaitPkt, \
  181.     , DOS_BASE_NAME)
  182.  
  183. #define ReplyPkt(dp, res1, res2) \
  184.     LP3NR(0x102, ReplyPkt, struct DosPacket *, dp, d1, LONG, res1, d2, LONG, res2, d3, \
  185.     , DOS_BASE_NAME)
  186.  
  187. #define AbortPkt(port, pkt) \
  188.     LP2NR(0x108, AbortPkt, struct MsgPort *, port, d1, struct DosPacket *, pkt, d2, \
  189.     , DOS_BASE_NAME)
  190.  
  191. #define LockRecord(fh, offset, length, mode, timeout) \
  192.     LP5(0x10E, BOOL, LockRecord, BPTR, fh, d1, ULONG, offset, d2, ULONG, length, d3, ULONG, mode, d4, ULONG, timeout, d5, \
  193.     , DOS_BASE_NAME)
  194.  
  195. #define LockRecords(recArray, timeout) \
  196.     LP2(0x114, BOOL, LockRecords, struct RecordLock *, recArray, d1, ULONG, timeout, d2, \
  197.     , DOS_BASE_NAME)
  198.  
  199. #define UnLockRecord(fh, offset, length) \
  200.     LP3(0x11A, BOOL, UnLockRecord, BPTR, fh, d1, ULONG, offset, d2, ULONG, length, d3, \
  201.     , DOS_BASE_NAME)
  202.  
  203. #define UnLockRecords(recArray) \
  204.     LP1(0x120, BOOL, UnLockRecords, struct RecordLock *, recArray, d1, \
  205.     , DOS_BASE_NAME)
  206.  
  207. #define SelectInput(fh) \
  208.     LP1(0x126, BPTR, SelectInput, BPTR, fh, d1, \
  209.     , DOS_BASE_NAME)
  210.  
  211. #define SelectOutput(fh) \
  212.     LP1(0x12C, BPTR, SelectOutput, BPTR, fh, d1, \
  213.     , DOS_BASE_NAME)
  214.  
  215. #define FGetC(fh) \
  216.     LP1(0x132, LONG, FGetC, BPTR, fh, d1, \
  217.     , DOS_BASE_NAME)
  218.  
  219. #define FPutC(fh, ch) \
  220.     LP2(0x138, LONG, FPutC, BPTR, fh, d1, LONG, ch, d2, \
  221.     , DOS_BASE_NAME)
  222.  
  223. #define UnGetC(fh, character) \
  224.     LP2(0x13E, LONG, UnGetC, BPTR, fh, d1, LONG, character, d2, \
  225.     , DOS_BASE_NAME)
  226.  
  227. #define FRead(fh, block, blocklen, number) \
  228.     LP4(0x144, LONG, FRead, BPTR, fh, d1, APTR, block, d2, ULONG, blocklen, d3, ULONG, number, d4, \
  229.     , DOS_BASE_NAME)
  230.  
  231. #define FWrite(fh, block, blocklen, number) \
  232.     LP4(0x14A, LONG, FWrite, BPTR, fh, d1, CONST APTR, block, d2, ULONG, blocklen, d3, ULONG, number, d4, \
  233.     , DOS_BASE_NAME)
  234.  
  235. #define FGets(fh, buf, buflen) \
  236.     LP3(0x150, STRPTR, FGets, BPTR, fh, d1, STRPTR, buf, d2, ULONG, buflen, d3, \
  237.     , DOS_BASE_NAME)
  238.  
  239. #define FPuts(fh, str) \
  240.     LP2(0x156, LONG, FPuts, BPTR, fh, d1, CONST_STRPTR, str, d2, \
  241.     , DOS_BASE_NAME)
  242.  
  243. #define VFWritef(fh, format, argarray) \
  244.     LP3NR(0x15C, VFWritef, BPTR, fh, d1, CONST_STRPTR, format, d2, CONST LONG *, argarray, d3, \
  245.     , DOS_BASE_NAME)
  246.  
  247. #ifndef NO_INLINE_STDARG
  248. #define FWritef(fh, format, tags...) \
  249.     ({ULONG _tags[] = {tags}; VFWritef((fh), (format), (CONST LONG *) _tags);})
  250. #endif
  251.  
  252. #define VFPrintf(fh, format, argarray) \
  253.     LP3(0x162, LONG, VFPrintf, BPTR, fh, d1, CONST_STRPTR, format, d2, CONST APTR, argarray, d3, \
  254.     , DOS_BASE_NAME)
  255.  
  256. #ifndef NO_INLINE_STDARG
  257. #define FPrintf(fh, format, tags...) \
  258.     ({ULONG _tags[] = {tags}; VFPrintf((fh), (format), (CONST APTR) _tags);})
  259. #endif
  260.  
  261. #define Flush(fh) \
  262.     LP1(0x168, LONG, Flush, BPTR, fh, d1, \
  263.     , DOS_BASE_NAME)
  264.  
  265. #define SetVBuf(fh, buff, type, size) \
  266.     LP4(0x16E, LONG, SetVBuf, BPTR, fh, d1, STRPTR, buff, d2, LONG, type, d3, LONG, size, d4, \
  267.     , DOS_BASE_NAME)
  268.  
  269. #define DupLockFromFH(fh) \
  270.     LP1(0x174, BPTR, DupLockFromFH, BPTR, fh, d1, \
  271.     , DOS_BASE_NAME)
  272.  
  273. #define OpenFromLock(lock) \
  274.     LP1(0x17A, BPTR, OpenFromLock, BPTR, lock, d1, \
  275.     , DOS_BASE_NAME)
  276.  
  277. #define ParentOfFH(fh) \
  278.     LP1(0x180, BPTR, ParentOfFH, BPTR, fh, d1, \
  279.     , DOS_BASE_NAME)
  280.  
  281. #define ExamineFH(fh, fib) \
  282.     LP2(0x186, BOOL, ExamineFH, BPTR, fh, d1, struct FileInfoBlock *, fib, d2, \
  283.     , DOS_BASE_NAME)
  284.  
  285. #define SetFileDate(name, date) \
  286.     LP2(0x18C, LONG, SetFileDate, CONST_STRPTR, name, d1, CONST struct DateStamp *, date, d2, \
  287.     , DOS_BASE_NAME)
  288.  
  289. #define NameFromLock(lock, buffer, len) \
  290.     LP3(0x192, LONG, NameFromLock, BPTR, lock, d1, STRPTR, buffer, d2, LONG, len, d3, \
  291.     , DOS_BASE_NAME)
  292.  
  293. #define NameFromFH(fh, buffer, len) \
  294.     LP3(0x198, LONG, NameFromFH, BPTR, fh, d1, STRPTR, buffer, d2, LONG, len, d3, \
  295.     , DOS_BASE_NAME)
  296.  
  297. #define SplitName(name, separator, buf, oldpos, size) \
  298.     LP5(0x19E, WORD, SplitName, CONST_STRPTR, name, d1, ULONG, separator, d2, STRPTR, buf, d3, LONG, oldpos, d4, LONG, size, d5, \
  299.     , DOS_BASE_NAME)
  300.  
  301. #define SameLock(lock1, lock2) \
  302.     LP2(0x1A4, LONG, SameLock, BPTR, lock1, d1, BPTR, lock2, d2, \
  303.     , DOS_BASE_NAME)
  304.  
  305. #define SetMode(fh, mode) \
  306.     LP2(0x1AA, LONG, SetMode, BPTR, fh, d1, LONG, mode, d2, \
  307.     , DOS_BASE_NAME)
  308.  
  309. #define ExAll(lock, buffer, size, data, control) \
  310.     LP5(0x1B0, LONG, ExAll, BPTR, lock, d1, struct ExAllData *, buffer, d2, LONG, size, d3, LONG, data, d4, struct ExAllControl *, control, d5, \
  311.     , DOS_BASE_NAME)
  312.  
  313. #define ReadLink(port, lock, path, buffer, size) \
  314.     LP5(0x1B6, LONG, ReadLink, struct MsgPort *, port, d1, BPTR, lock, d2, CONST_STRPTR, path, d3, STRPTR, buffer, d4, ULONG, size, d5, \
  315.     , DOS_BASE_NAME)
  316.  
  317. #define MakeLink(name, dest, soft) \
  318.     LP3(0x1BC, LONG, MakeLink, CONST_STRPTR, name, d1, LONG, dest, d2, LONG, soft, d3, \
  319.     , DOS_BASE_NAME)
  320.  
  321. #define ChangeMode(type, fh, newmode) \
  322.     LP3(0x1C2, LONG, ChangeMode, LONG, type, d1, BPTR, fh, d2, LONG, newmode, d3, \
  323.     , DOS_BASE_NAME)
  324.  
  325. #define SetFileSize(fh, pos, mode) \
  326.     LP3(0x1C8, LONG, SetFileSize, BPTR, fh, d1, LONG, pos, d2, LONG, mode, d3, \
  327.     , DOS_BASE_NAME)
  328.  
  329. #define SetIoErr(result) \
  330.     LP1(0x1CE, LONG, SetIoErr, LONG, result, d1, \
  331.     , DOS_BASE_NAME)
  332.  
  333. #define Fault(code, header, buffer, len) \
  334.     LP4(0x1D4, BOOL, Fault, LONG, code, d1, STRPTR, header, d2, STRPTR, buffer, d3, LONG, len, d4, \
  335.     , DOS_BASE_NAME)
  336.  
  337. #define PrintFault(code, header) \
  338.     LP2(0x1DA, BOOL, PrintFault, LONG, code, d1, CONST_STRPTR, header, d2, \
  339.     , DOS_BASE_NAME)
  340.  
  341. #define ErrorReport(code, type, arg1, device) \
  342.     LP4(0x1E0, LONG, ErrorReport, LONG, code, d1, LONG, type, d2, ULONG, arg1, d3, struct MsgPort *, device, d4, \
  343.     , DOS_BASE_NAME)
  344.  
  345. #define Cli() \
  346.     LP0(0x1EC, struct CommandLineInterface *, Cli, \
  347.     , DOS_BASE_NAME)
  348.  
  349. #define CreateNewProc(tags) \
  350.     LP1(0x1F2, struct Process *, CreateNewProc, CONST struct TagItem *, tags, d1, \
  351.     , DOS_BASE_NAME)
  352.  
  353. #ifndef NO_INLINE_STDARG
  354. #define CreateNewProcTags(tags...) \
  355.     ({ULONG _tags[] = {tags}; CreateNewProc((CONST struct TagItem *) _tags);})
  356. #endif
  357.  
  358. #define CreateNewProcTagList(tags) CreateNewProc((tags))
  359.  
  360. #define RunCommand(seg, stack, paramptr, paramlen) \
  361.     LP4(0x1F8, LONG, RunCommand, BPTR, seg, d1, LONG, stack, d2, CONST_STRPTR, paramptr, d3, LONG, paramlen, d4, \
  362.     , DOS_BASE_NAME)
  363.  
  364. #define GetConsoleTask() \
  365.     LP0(0x1FE, struct MsgPort *, GetConsoleTask, \
  366.     , DOS_BASE_NAME)
  367.  
  368. #define SetConsoleTask(task) \
  369.     LP1(0x204, struct MsgPort *, SetConsoleTask, CONST struct MsgPort *, task, d1, \
  370.     , DOS_BASE_NAME)
  371.  
  372. #define GetFileSysTask() \
  373.     LP0(0x20A, struct MsgPort *, GetFileSysTask, \
  374.     , DOS_BASE_NAME)
  375.  
  376. #define SetFileSysTask(task) \
  377.     LP1(0x210, struct MsgPort *, SetFileSysTask, CONST struct MsgPort *, task, d1, \
  378.     , DOS_BASE_NAME)
  379.  
  380. #define GetArgStr() \
  381.     LP0(0x216, STRPTR, GetArgStr, \
  382.     , DOS_BASE_NAME)
  383.  
  384. #define SetArgStr(string) \
  385.     LP1(0x21C, BOOL, SetArgStr, CONST_STRPTR, string, d1, \
  386.     , DOS_BASE_NAME)
  387.  
  388. #define FindCliProc(num) \
  389.     LP1(0x222, struct Process *, FindCliProc, ULONG, num, d1, \
  390.     , DOS_BASE_NAME)
  391.  
  392. #define MaxCli() \
  393.     LP0(0x228, ULONG, MaxCli, \
  394.     , DOS_BASE_NAME)
  395.  
  396. #define SetCurrentDirName(name) \
  397.     LP1(0x22E, BOOL, SetCurrentDirName, CONST_STRPTR, name, d1, \
  398.     , DOS_BASE_NAME)
  399.  
  400. #define GetCurrentDirName(buf, len) \
  401.     LP2(0x234, BOOL, GetCurrentDirName, STRPTR, buf, d1, LONG, len, d2, \
  402.     , DOS_BASE_NAME)
  403.  
  404. #define SetProgramName(name) \
  405.     LP1(0x23A, BOOL, SetProgramName, CONST_STRPTR, name, d1, \
  406.     , DOS_BASE_NAME)
  407.  
  408. #define GetProgramName(buf, len) \
  409.     LP2(0x240, BOOL, GetProgramName, STRPTR, buf, d1, LONG, len, d2, \
  410.     , DOS_BASE_NAME)
  411.  
  412. #define SetPrompt(name) \
  413.     LP1(0x246, BOOL, SetPrompt, CONST_STRPTR, name, d1, \
  414.     , DOS_BASE_NAME)
  415.  
  416. #define GetPrompt(buf, len) \
  417.     LP2(0x24C, BOOL, GetPrompt, STRPTR, buf, d1, LONG, len, d2, \
  418.     , DOS_BASE_NAME)
  419.  
  420. #define SetProgramDir(lock) \
  421.     LP1(0x252, BPTR, SetProgramDir, BPTR, lock, d1, \
  422.     , DOS_BASE_NAME)
  423.  
  424. #define GetProgramDir() \
  425.     LP0(0x258, BPTR, GetProgramDir, \
  426.     , DOS_BASE_NAME)
  427.  
  428. #define SystemTagList(command, tags) \
  429.     LP2(0x25E, LONG, SystemTagList, CONST_STRPTR, command, d1, CONST struct TagItem *, tags, d2, \
  430.     , DOS_BASE_NAME)
  431.  
  432. #ifndef NO_INLINE_STDARG
  433. #define SystemTags(command, tags...) \
  434.     ({ULONG _tags[] = {tags}; SystemTagList((command), (CONST struct TagItem *) _tags);})
  435. #endif
  436.  
  437. #define System(command, tags) SystemTagList((command), (tags))
  438.  
  439. #define AssignLock(name, lock) \
  440.     LP2(0x264, LONG, AssignLock, CONST_STRPTR, name, d1, BPTR, lock, d2, \
  441.     , DOS_BASE_NAME)
  442.  
  443. #define AssignLate(name, path) \
  444.     LP2(0x26A, BOOL, AssignLate, CONST_STRPTR, name, d1, CONST_STRPTR, path, d2, \
  445.     , DOS_BASE_NAME)
  446.  
  447. #define AssignPath(name, path) \
  448.     LP2(0x270, BOOL, AssignPath, CONST_STRPTR, name, d1, CONST_STRPTR, path, d2, \
  449.     , DOS_BASE_NAME)
  450.  
  451. #define AssignAdd(name, lock) \
  452.     LP2(0x276, BOOL, AssignAdd, CONST_STRPTR, name, d1, BPTR, lock, d2, \
  453.     , DOS_BASE_NAME)
  454.  
  455. #define RemAssignList(name, lock) \
  456.     LP2(0x27C, LONG, RemAssignList, CONST_STRPTR, name, d1, BPTR, lock, d2, \
  457.     , DOS_BASE_NAME)
  458.  
  459. #define GetDeviceProc(name, dp) \
  460.     LP2(0x282, struct DevProc *, GetDeviceProc, CONST_STRPTR, name, d1, struct DevProc *, dp, d2, \
  461.     , DOS_BASE_NAME)
  462.  
  463. #define FreeDeviceProc(dp) \
  464.     LP1NR(0x288, FreeDeviceProc, struct DevProc *, dp, d1, \
  465.     , DOS_BASE_NAME)
  466.  
  467. #define LockDosList(flags) \
  468.     LP1(0x28E, struct DosList *, LockDosList, ULONG, flags, d1, \
  469.     , DOS_BASE_NAME)
  470.  
  471. #define UnLockDosList(flags) \
  472.     LP1NR(0x294, UnLockDosList, ULONG, flags, d1, \
  473.     , DOS_BASE_NAME)
  474.  
  475. #define AttemptLockDosList(flags) \
  476.     LP1(0x29A, struct DosList *, AttemptLockDosList, ULONG, flags, d1, \
  477.     , DOS_BASE_NAME)
  478.  
  479. #define RemDosEntry(dlist) \
  480.     LP1(0x2A0, BOOL, RemDosEntry, struct DosList *, dlist, d1, \
  481.     , DOS_BASE_NAME)
  482.  
  483. #define AddDosEntry(dlist) \
  484.     LP1(0x2A6, LONG, AddDosEntry, struct DosList *, dlist, d1, \
  485.     , DOS_BASE_NAME)
  486.  
  487. #define FindDosEntry(dlist, name, flags) \
  488.     LP3(0x2AC, struct DosList *, FindDosEntry, CONST struct DosList *, dlist, d1, CONST_STRPTR, name, d2, ULONG, flags, d3, \
  489.     , DOS_BASE_NAME)
  490.  
  491. #define NextDosEntry(dlist, flags) \
  492.     LP2(0x2B2, struct DosList *, NextDosEntry, CONST struct DosList *, dlist, d1, ULONG, flags, d2, \
  493.     , DOS_BASE_NAME)
  494.  
  495. #define MakeDosEntry(name, type) \
  496.     LP2(0x2B8, struct DosList *, MakeDosEntry, CONST_STRPTR, name, d1, LONG, type, d2, \
  497.     , DOS_BASE_NAME)
  498.  
  499. #define FreeDosEntry(dlist) \
  500.     LP1NR(0x2BE, FreeDosEntry, struct DosList *, dlist, d1, \
  501.     , DOS_BASE_NAME)
  502.  
  503. #define IsFileSystem(name) \
  504.     LP1(0x2C4, BOOL, IsFileSystem, CONST_STRPTR, name, d1, \
  505.     , DOS_BASE_NAME)
  506.  
  507. #define Format(filesystem, volumename, dostype) \
  508.     LP3(0x2CA, BOOL, Format, CONST_STRPTR, filesystem, d1, CONST_STRPTR, volumename, d2, ULONG, dostype, d3, \
  509.     , DOS_BASE_NAME)
  510.  
  511. #define Relabel(drive, newname) \
  512.     LP2(0x2D0, LONG, Relabel, CONST_STRPTR, drive, d1, CONST_STRPTR, newname, d2, \
  513.     , DOS_BASE_NAME)
  514.  
  515. #define Inhibit(name, onoff) \
  516.     LP2(0x2D6, LONG, Inhibit, CONST_STRPTR, name, d1, LONG, onoff, d2, \
  517.     , DOS_BASE_NAME)
  518.  
  519. #define AddBuffers(name, number) \
  520.     LP2(0x2DC, LONG, AddBuffers, CONST_STRPTR, name, d1, LONG, number, d2, \
  521.     , DOS_BASE_NAME)
  522.  
  523. #define CompareDates(date1, date2) \
  524.     LP2(0x2E2, LONG, CompareDates, CONST struct DateStamp *, date1, d1, CONST struct DateStamp *, date2, d2, \
  525.     , DOS_BASE_NAME)
  526.  
  527. #define DateToStr(datetime) \
  528.     LP1(0x2E8, LONG, DateToStr, struct DateTime *, datetime, d1, \
  529.     , DOS_BASE_NAME)
  530.  
  531. #define StrToDate(datetime) \
  532.     LP1(0x2EE, LONG, StrToDate, struct DateTime *, datetime, d1, \
  533.     , DOS_BASE_NAME)
  534.  
  535. #define InternalLoadSeg(fh, table, funcarray, stack) \
  536.     LP4(0x2F4, BPTR, InternalLoadSeg, BPTR, fh, d0, BPTR, table, a0, CONST LONG *, funcarray, a1, LONG *, stack, a2, \
  537.     , DOS_BASE_NAME)
  538.  
  539. #define InternalUnLoadSeg(seglist, freefunc) \
  540.     LP2FP(0x2FA, BOOL, InternalUnLoadSeg, BPTR, seglist, d1, __fpt, freefunc, a1, \
  541.     , DOS_BASE_NAME, VOID (*__fpt)())
  542.  
  543. #define NewLoadSeg(file, tags) \
  544.     LP2(0x300, BPTR, NewLoadSeg, CONST_STRPTR, file, d1, CONST struct TagItem *, tags, d2, \
  545.     , DOS_BASE_NAME)
  546.  
  547. #ifndef NO_INLINE_STDARG
  548. #define NewLoadSegTags(file, tags...) \
  549.     ({ULONG _tags[] = {tags}; NewLoadSeg((file), (CONST struct TagItem *) _tags);})
  550. #endif
  551.  
  552. #define NewLoadSegTagList(file, tags) NewLoadSeg((file), (tags))
  553.  
  554. #define AddSegment(name, seg, system) \
  555.     LP3(0x306, LONG, AddSegment, CONST_STRPTR, name, d1, BPTR, seg, d2, LONG, system, d3, \
  556.     , DOS_BASE_NAME)
  557.  
  558. #define FindSegment(name, seg, system) \
  559.     LP3(0x30C, struct Segment *, FindSegment, CONST_STRPTR, name, d1, CONST struct Segment *, seg, d2, LONG, system, d3, \
  560.     , DOS_BASE_NAME)
  561.  
  562. #define RemSegment(seg) \
  563.     LP1(0x312, LONG, RemSegment, struct Segment *, seg, d1, \
  564.     , DOS_BASE_NAME)
  565.  
  566. #define CheckSignal(mask) \
  567.     LP1(0x318, LONG, CheckSignal, LONG, mask, d1, \
  568.     , DOS_BASE_NAME)
  569.  
  570. #define ReadArgs(arg_template, array, args) \
  571.     LP3(0x31E, struct RDArgs *, ReadArgs, CONST_STRPTR, arg_template, d1, LONG *, array, d2, struct RDArgs *, args, d3, \
  572.     , DOS_BASE_NAME)
  573.  
  574. #define FindArg(keyword, arg_template) \
  575.     LP2(0x324, LONG, FindArg, CONST_STRPTR, keyword, d1, CONST_STRPTR, arg_template, d2, \
  576.     , DOS_BASE_NAME)
  577.  
  578. #define ReadItem(name, maxchars, cSource) \
  579.     LP3(0x32A, LONG, ReadItem, CONST_STRPTR, name, d1, LONG, maxchars, d2, struct CSource *, cSource, d3, \
  580.     , DOS_BASE_NAME)
  581.  
  582. #define StrToLong(string, value) \
  583.     LP2(0x330, LONG, StrToLong, CONST_STRPTR, string, d1, LONG *, value, d2, \
  584.     , DOS_BASE_NAME)
  585.  
  586. #define MatchFirst(pat, anchor) \
  587.     LP2(0x336, LONG, MatchFirst, CONST_STRPTR, pat, d1, struct AnchorPath *, anchor, d2, \
  588.     , DOS_BASE_NAME)
  589.  
  590. #define MatchNext(anchor) \
  591.     LP1(0x33C, LONG, MatchNext, struct AnchorPath *, anchor, d1, \
  592.     , DOS_BASE_NAME)
  593.  
  594. #define MatchEnd(anchor) \
  595.     LP1NR(0x342, MatchEnd, struct AnchorPath *, anchor, d1, \
  596.     , DOS_BASE_NAME)
  597.  
  598. #define ParsePattern(pat, buf, buflen) \
  599.     LP3(0x348, LONG, ParsePattern, CONST_STRPTR, pat, d1, STRPTR, buf, d2, LONG, buflen, d3, \
  600.     , DOS_BASE_NAME)
  601.  
  602. #define MatchPattern(pat, str) \
  603.     LP2(0x34E, BOOL, MatchPattern, CONST_STRPTR, pat, d1, STRPTR, str, d2, \
  604.     , DOS_BASE_NAME)
  605.  
  606. #define FreeArgs(args) \
  607.     LP1NR(0x35A, FreeArgs, struct RDArgs *, args, d1, \
  608.     , DOS_BASE_NAME)
  609.  
  610. #define FilePart(path) \
  611.     LP1(0x366, STRPTR, FilePart, CONST_STRPTR, path, d1, \
  612.     , DOS_BASE_NAME)
  613.  
  614. #define PathPart(path) \
  615.     LP1(0x36C, STRPTR, PathPart, CONST_STRPTR, path, d1, \
  616.     , DOS_BASE_NAME)
  617.  
  618. #define AddPart(dirname, filename, size) \
  619.     LP3(0x372, BOOL, AddPart, STRPTR, dirname, d1, CONST_STRPTR, filename, d2, ULONG, size, d3, \
  620.     , DOS_BASE_NAME)
  621.  
  622. #define StartNotify(notify) \
  623.     LP1(0x378, BOOL, StartNotify, struct NotifyRequest *, notify, d1, \
  624.     , DOS_BASE_NAME)
  625.  
  626. #define EndNotify(notify) \
  627.     LP1NR(0x37E, EndNotify, struct NotifyRequest *, notify, d1, \
  628.     , DOS_BASE_NAME)
  629.  
  630. #define SetVar(name, buffer, size, flags) \
  631.     LP4(0x384, BOOL, SetVar, CONST_STRPTR, name, d1, CONST_STRPTR, buffer, d2, LONG, size, d3, LONG, flags, d4, \
  632.     , DOS_BASE_NAME)
  633.  
  634. #define GetVar(name, buffer, size, flags) \
  635.     LP4(0x38A, LONG, GetVar, CONST_STRPTR, name, d1, STRPTR, buffer, d2, LONG, size, d3, LONG, flags, d4, \
  636.     , DOS_BASE_NAME)
  637.  
  638. #define DeleteVar(name, flags) \
  639.     LP2(0x390, LONG, DeleteVar, CONST_STRPTR, name, d1, ULONG, flags, d2, \
  640.     , DOS_BASE_NAME)
  641.  
  642. #define FindVar(name, type) \
  643.     LP2(0x396, struct LocalVar *, FindVar, CONST_STRPTR, name, d1, ULONG, type, d2, \
  644.     , DOS_BASE_NAME)
  645.  
  646. #define CliInitNewcli(dp) \
  647.     LP1(0x3A2, LONG, CliInitNewcli, struct DosPacket *, dp, a0, \
  648.     , DOS_BASE_NAME)
  649.  
  650. #define CliInitRun(dp) \
  651.     LP1(0x3A8, LONG, CliInitRun, struct DosPacket *, dp, a0, \
  652.     , DOS_BASE_NAME)
  653.  
  654. #define WriteChars(buf, buflen) \
  655.     LP2(0x3AE, LONG, WriteChars, CONST_STRPTR, buf, d1, ULONG, buflen, d2, \
  656.     , DOS_BASE_NAME)
  657.  
  658. #define PutStr(str) \
  659.     LP1(0x3B4, LONG, PutStr, CONST_STRPTR, str, d1, \
  660.     , DOS_BASE_NAME)
  661.  
  662. #define VPrintf(format, argarray) \
  663.     LP2(0x3BA, LONG, VPrintf, CONST_STRPTR, format, d1, CONST APTR, argarray, d2, \
  664.     , DOS_BASE_NAME)
  665.  
  666. #ifndef NO_INLINE_STDARG
  667. #define Printf(format, tags...) \
  668.     ({ULONG _tags[] = {tags}; VPrintf((format), (CONST APTR) _tags);})
  669. #endif
  670.  
  671. #define ParsePatternNoCase(pat, buf, buflen) \
  672.     LP3(0x3C6, LONG, ParsePatternNoCase, CONST_STRPTR, pat, d1, UBYTE *, buf, d2, LONG, buflen, d3, \
  673.     , DOS_BASE_NAME)
  674.  
  675. #define MatchPatternNoCase(pat, str) \
  676.     LP2(0x3CC, BOOL, MatchPatternNoCase, CONST_STRPTR, pat, d1, STRPTR, str, d2, \
  677.     , DOS_BASE_NAME)
  678.  
  679. #define SameDevice(lock1, lock2) \
  680.     LP2(0x3D8, BOOL, SameDevice, BPTR, lock1, d1, BPTR, lock2, d2, \
  681.     , DOS_BASE_NAME)
  682.  
  683. #define ExAllEnd(lock, buffer, size, data, control) \
  684.     LP5NR(0x3DE, ExAllEnd, BPTR, lock, d1, struct ExAllData *, buffer, d2, LONG, size, d3, LONG, data, d4, struct ExAllControl *, control, d5, \
  685.     , DOS_BASE_NAME)
  686.  
  687. #define SetOwner(name, owner_info) \
  688.     LP2(0x3E4, BOOL, SetOwner, CONST_STRPTR, name, d1, LONG, owner_info, d2, \
  689.     , DOS_BASE_NAME)
  690.  
  691. #endif /*  _INLINE_DOS_H  */
  692.